home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Mediterranean / Mediterranean Large.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  51.7 KB  |  1,626 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Mediterranean Large.rmv
  4. //
  5. //
  6. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  7. // PROPRIETARY and CONFIDENTIAL.
  8. //
  9. // $Author: Scott Marison $
  10. // $Date: 9/14/01 10:07a $
  11. // $Revision: 11 $
  12. // $Revision: 11 $Revision: 8
  13. //   Adjusted Angle between team members 
  14. // Revision: 9 
  15. //    Pushed players and outer neutrals toward the map edge
  16. //    increased land, trees, decreased outer neutrals and flat land 
  17. //    Assumes Initial Step = 64 in Mediterranean.rmv
  18. //  Revision: 15 Revised for miniaturization 
  19. //  Revision: 16 Elevation
  20. //  Revision: 17 Revised # of resources 3 by 3
  21. //  Revision: 18 8+ player adjustment and enhanced resource placement 
  22. //  Revision: 19 General Adjustments
  23. //  Revision: 20 Reduced congestion 
  24. //  Revision: 20c Small Enhancements 
  25. //  Revision: 22 Design Enhancements 
  26. //  Revision: 23 Reduced Resources
  27. //  Revision: 24 Added Chance of steep cliffs 
  28. //  Revision: 26 Evened-out resource distribution 
  29. //  Revision: 28 Moved resources 2 tiles further from Capitol
  30. //  Revision: 29 Added gold and iron to 5+ player maps
  31. //  Revision: 30 Changed convergance from 16,250 to 32,1
  32. //
  33. //////////////////////////////////////////////////////////////////////
  34.  
  35. #if            NOTDEFINED(MEDITERRANEAN_LARGE_RMV)
  36. #define        (MEDITERRANEAN_LARGE_RMV,1)
  37.  
  38. //////////////////////////////////////////////////////////////////////
  39. // Definitions we are required to define for Mediterranean maps
  40. //////////////////////////////////////////////////////////////////////
  41.  
  42. ResourcePlacementLimit (Gold,     8,    11)
  43. ResourcePlacementLimit (Steel,     8,     11)
  44. ResourcePlacementLimit (Stone,     8,     11)
  45. ResourcePlacementLimit (Berry,     7,     10)
  46. ResourcePlacementLimit (Fish,     1,    50)
  47. ResourcePlacementLimit (Tree,     3,     6)
  48. ResourcePlacementLimit (Animal,     7,     15)
  49.  
  50. #if Is2Players
  51. //////////////////////////////////////////////////////////////////////
  52. // 2 PLAYERS...
  53. //////////////////////////////////////////////////////////////////////
  54.  
  55. ResourceSeperation    5 
  56.  
  57. //////////////////////////////////////////////////////////////////////
  58. // terrain definitions
  59. #define        (kMinIntElevation,            -8)
  60.  
  61. #if        PERCENT(80)
  62.   #define        (kMaxIntElevation,                 8)
  63. #else
  64.   #define        (kMaxIntElevation,                15)
  65. #endif 
  66.  
  67. #define        (kElevationScale,                1)
  68. #define        (kPercentLand,                Between(.86, .86))
  69. #define        (kWaterBorder,                0)
  70. #define        (kHeightMapChaos,                Between(10, 14))
  71.                                             
  72. #define        (kMinimumStartPositionToMapEdge    4)
  73. #define        (kOuterPushFromMapCenter        34)
  74. #define        (kInnerPushFromMapCenter         24)
  75.  
  76. #define        (kConvergentSampleSize,            32) 
  77. #define        (kConvergentThreshold,            100)
  78.  
  79. //////////////////////////////////////////////////////////////////////
  80. // player definitions
  81. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  82. #define        (kPlayerInnerRadius,            0.6)
  83. #define        (kPlayerOuterRadius,            0.99)
  84. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  85. #define        (kPlayerPercentFlat,            Between(0.86, 0.86))
  86. #define        (kPlayerLandChaos,            0.8)
  87. #define        (kPlayerLandClumps,            1)
  88. #define        (kPlayerFlatChaos,            0.8)
  89. #define        (kPlayerFlatClumps,            1)
  90. #define        (kPlayerTreePercentage,            0.04)
  91.  
  92.  
  93. //////////////////////////////////////////////////////////////////////
  94. // inner neutral definitions
  95. #define        (kNeutralInnerRadius,            0.45)
  96. #define        (kNeutralOuterRadius,            0.45)
  97. #define        (kNeutralOptimalFactor,            0.7)
  98. #define        (kNumInnerNeutrals,            Between(16, 16))
  99. #define        (kInnerNeutralPercentLand,        0.16)
  100. #define        (kInnerNeutralPercentFlat,        Between(.9, .9))
  101. #define        (kInnerNeutralTreePercentage,          0.3)
  102. #define        (kInnerNeutralLandChaos,        0.9)
  103. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  104. #define        (kInnerNeutralFlatChaos,        0.8)
  105. #define        (kInnerNeutralFlatClumps,        1)
  106.  
  107.  
  108. //////////////////////////////////////////////////////////////////////
  109. // outer neutral definitions
  110. #define        (kNumOuterNeutrals,            20)
  111. #define        (kOuterNeutralPercentLand,        0.75)
  112. #define        (kOuterNeutralPercentFlat,        Between(.9, .9))
  113. #define        (kOuterNeutralTreePercentage,          0.15)
  114. #define        (kOuterNeutralLandChaos,        0.8)
  115. #define        (kOuterNeutralLandClumps,        1)
  116. #define        (kOuterNeutralFlatChaos,        0.8)
  117. #define        (kOuterNeutralFlatClumps,        1)
  118.  
  119.  
  120. //////////////////////////////////////////////////////////////////////
  121. // resource definitions
  122. #define        (kMaxResourceElevation,            3)
  123. #define        (kResourceToEdgeDistance,        1)
  124. #define        (kResourceToWaterDistance,        3)
  125.  
  126. #define        (kAnimalPerPlayer,            0)
  127. #define        (kAnimalPerNeutral,            0)
  128.  
  129. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  130.   #define  (kBerryPerPlayer,    1) 
  131.   #define  (kBerryPerNeutral,      6)
  132. #else
  133.   #define  (kBerryPerPlayer,    1)
  134.   #define  (kBerryPerNeutral,      0)
  135. #endif 
  136.  
  137. #define        (kFishPerPlayer,                0)
  138. #define        (kFishPerNeutral,                60)
  139.  
  140. #define        (kGoldPerPlayer,                1)
  141. #define        (kGoldPerNeutral,                7)
  142.  
  143. #define        (kOilPerPlayer,                0)
  144. #define        (kOilPerNeutral,                0)
  145.  
  146. #define        (kSteelPerPlayer,                1)
  147. #define        (kSteelPerNeutral,            7)
  148.  
  149. #define        (kStonePerPlayer,                1)
  150. #define        (kStonePerNeutral,            3)
  151.  
  152. #define        (kTreePerPlayer,                2)
  153. #define        (kTreePerNeutral,                0)
  154.  
  155.  
  156. //////////////////////////////////////////////////////////////////////
  157. // forest definitions
  158. #define        (kForestFreeRadius,            10.0)
  159. #define        (kForestsPerPlayer,            1)
  160. #define        (kForestChaosLevel,            .1)
  161. #define        (kMaxClumpsPerForest,              3)
  162.  
  163.  
  164. #elif Is3Players
  165. //////////////////////////////////////////////////////////////////////
  166. // 3 PLAYERS...
  167. //////////////////////////////////////////////////////////////////////
  168.  
  169. ResourceSeperation    5 
  170.  
  171. //////////////////////////////////////////////////////////////////////
  172. // terrain definitions
  173. #define        (kMinIntElevation,            -8)
  174.  
  175. #if        PERCENT(80)
  176.   #define        (kMaxIntElevation,             8)
  177. #else
  178.   #define        (kMaxIntElevation,            15)
  179. #endif 
  180.  
  181. #define        (kElevationScale,                1)
  182. #define        (kPercentLand,                Between(.86, .86))
  183. #define        (kWaterBorder,                0)
  184. #define        (kHeightMapChaos,                Between(10, 14))
  185.                                             
  186. #define        (kMinimumStartPositionToMapEdge    4)
  187. #define        (kOuterPushFromMapCenter        34)
  188. #define        (kInnerPushFromMapCenter         24)
  189.  
  190. #define        (kConvergentSampleSize,            32) 
  191. #define        (kConvergentThreshold,            1)
  192.  
  193. //////////////////////////////////////////////////////////////////////
  194. // player definitions
  195. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  196. #define        (kPlayerInnerRadius,            0.6)
  197. #define        (kPlayerOuterRadius,            0.99)
  198. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  199. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  200. #define        (kPlayerLandChaos,            0.8)
  201. #define        (kPlayerLandClumps,            1)
  202. #define        (kPlayerFlatChaos,            0.8)
  203. #define        (kPlayerFlatClumps,            2)
  204. #define        (kPlayerTreePercentage,            0.04)
  205.  
  206. //////////////////////////////////////////////////////////////////////
  207. // inner neutral definitions
  208. #define        (kNeutralInnerRadius,            0.45)
  209. #define        (kNeutralOuterRadius,            0.45)
  210. #define        (kNeutralOptimalFactor,            0.7)
  211. #define        (kNumInnerNeutrals,            Between(16, 16))
  212. #define        (kInnerNeutralPercentLand,        0.17)
  213. #define        (kInnerNeutralPercentFlat,        Between(.9, .9))
  214. #define        (kInnerNeutralTreePercentage,          0.35)
  215. #define        (kInnerNeutralLandChaos,        1)
  216. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  217. #define        (kInnerNeutralFlatChaos,        0.8)
  218. #define        (kInnerNeutralFlatClumps,        1)
  219.  
  220.  
  221. //////////////////////////////////////////////////////////////////////
  222. // outer neutral definitions
  223. #define        (kNumOuterNeutrals,            20)
  224. #define        (kOuterNeutralPercentLand,        0.7)
  225. #define        (kOuterNeutralPercentFlat,        Between(.95, .95))
  226. #define        (kOuterNeutralTreePercentage,          0.12)
  227. #define        (kOuterNeutralLandChaos,        0.8)
  228. #define        (kOuterNeutralLandClumps,        1)
  229. #define        (kOuterNeutralFlatChaos,        0.8)
  230. #define        (kOuterNeutralFlatClumps,        1)
  231.  
  232.  
  233. //////////////////////////////////////////////////////////////////////
  234. // resource definitions
  235. #define        (kMaxResourceElevation,            3)
  236. #define        (kResourceToEdgeDistance,        1)
  237. #define        (kResourceToWaterDistance,        3)
  238.  
  239. #define        (kAnimalPerPlayer,            0)
  240. #define        (kAnimalPerNeutral,            0)
  241.  
  242. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  243.   #define  (kBerryPerPlayer,    1) 
  244.   #define  (kBerryPerNeutral,      8)
  245. #else
  246.   #define  (kBerryPerPlayer,    1)
  247.   #define  (kBerryPerNeutral,      0)
  248. #endif 
  249.  
  250. #define        (kFishPerPlayer,                0)
  251. #define        (kFishPerNeutral,                60)
  252.  
  253. #define        (kGoldPerPlayer,                1)
  254. #define        (kGoldPerNeutral,                9)
  255.  
  256. #define        (kOilPerPlayer,                0)
  257. #define        (kOilPerNeutral,                0)
  258.  
  259. #define        (kSteelPerPlayer,                1)
  260. #define        (kSteelPerNeutral,            9)
  261.  
  262. #define        (kStonePerPlayer,                1)
  263. #define        (kStonePerNeutral,            4)
  264.  
  265. #define        (kTreePerPlayer,                2)
  266. #define        (kTreePerNeutral,                0)
  267.  
  268.  
  269. //////////////////////////////////////////////////////////////////////
  270. // forest definitions
  271. #define        (kForestFreeRadius,            10.0)
  272. #define        (kForestsPerPlayer,            1)
  273. #define        (kForestChaosLevel,            .01)
  274. #define        (kMaxClumpsPerForest,              3)
  275.  
  276.  
  277. #elif Is4Players
  278. //////////////////////////////////////////////////////////////////////
  279. // 4 PLAYERS...
  280. //////////////////////////////////////////////////////////////////////
  281.  
  282. ResourceSeperation    5 
  283.  
  284. //////////////////////////////////////////////////////////////////////
  285. // terrain definitions
  286. #define        (kMinIntElevation,            -8)
  287.  
  288. #if        PERCENT(80)
  289.   #define        (kMaxIntElevation,             8)
  290. #else
  291.   #define        (kMaxIntElevation,            15)
  292. #endif 
  293.  
  294. #define        (kElevationScale,                1)
  295. #define        (kPercentLand,                Between(.86, .86))
  296. #define        (kWaterBorder,                0)
  297. #define        (kHeightMapChaos,                Between(10, 14))
  298.                                             
  299. #define        (kMinimumStartPositionToMapEdge    4)
  300. #define        (kOuterPushFromMapCenter        34)
  301. #define        (kInnerPushFromMapCenter         24)
  302.  
  303. #define        (kConvergentSampleSize,            32) 
  304. #define        (kConvergentThreshold,            1)
  305.  
  306.  
  307. //////////////////////////////////////////////////////////////////////
  308. // player definitions
  309. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  310. #define        (kPlayerInnerRadius,            0.6)
  311. #define        (kPlayerOuterRadius,            0.99)
  312. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  313. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  314. #define        (kPlayerLandChaos,            0.8)
  315. #define        (kPlayerLandClumps,            1)
  316. #define        (kPlayerFlatChaos,            0.8)
  317. #define        (kPlayerFlatClumps,            2)
  318. #define        (kPlayerTreePercentage,            0.04)
  319.  
  320.  
  321. //////////////////////////////////////////////////////////////////////
  322. // inner neutral definitions
  323. #define        (kNeutralInnerRadius,            0.45)
  324. #define        (kNeutralOuterRadius,            0.45)
  325. #define        (kNeutralOptimalFactor,            0.7)
  326. #define        (kNumInnerNeutrals,            Between(16, 16))
  327. #define        (kInnerNeutralPercentLand,        0.18)
  328. #define        (kInnerNeutralPercentFlat,        Between(.9, .9))
  329. #define        (kInnerNeutralTreePercentage,          0.35)
  330. #define        (kInnerNeutralLandChaos,        1)
  331. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  332. #define        (kInnerNeutralFlatChaos,        0.8)
  333. #define        (kInnerNeutralFlatClumps,        1)
  334.  
  335.  
  336. //////////////////////////////////////////////////////////////////////
  337. // outer neutral definitions
  338. #define        (kNumOuterNeutrals,            20)
  339. #define        (kOuterNeutralPercentLand,        0.65)
  340. #define        (kOuterNeutralPercentFlat,        Between(.9, .9))
  341. #define        (kOuterNeutralTreePercentage,          0.15)
  342. #define        (kOuterNeutralLandChaos,        0.8)
  343. #define        (kOuterNeutralLandClumps,        1)
  344. #define        (kOuterNeutralFlatChaos,        0.8)
  345. #define        (kOuterNeutralFlatClumps,        1)
  346.  
  347.  
  348. //////////////////////////////////////////////////////////////////////
  349. // resource definitions
  350. #define        (kMaxResourceElevation,            3)
  351. #define        (kResourceToEdgeDistance,        1)
  352. #define        (kResourceToWaterDistance,        3)
  353.  
  354. #define        (kAnimalPerPlayer,            0)
  355. #define        (kAnimalPerNeutral,            0)
  356.  
  357. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  358.   #define  (kBerryPerPlayer,    1) 
  359.   #define  (kBerryPerNeutral,      8)
  360. #else
  361.   #define  (kBerryPerPlayer,    1)
  362.   #define  (kBerryPerNeutral,      0)
  363. #endif 
  364.  
  365. #define        (kFishPerPlayer,                0)
  366. #define        (kFishPerNeutral,                60)
  367.  
  368. #define        (kGoldPerPlayer,                1)
  369. #define        (kGoldPerNeutral,                11)
  370.  
  371. #define        (kOilPerPlayer,                0)
  372. #define        (kOilPerNeutral,                0)
  373.  
  374. #define        (kSteelPerPlayer,                1)
  375. #define        (kSteelPerNeutral,            11)
  376.  
  377. #define        (kStonePerPlayer,                1)
  378. #define        (kStonePerNeutral,            5)
  379.  
  380. #define        (kTreePerPlayer,                2)
  381. #define        (kTreePerNeutral,                0)
  382.  
  383.  
  384. //////////////////////////////////////////////////////////////////////
  385. // forest definitions
  386. #define        (kForestFreeRadius,            10.0)
  387. #define        (kForestsPerPlayer,            1)
  388. #define        (kForestChaosLevel,            .01)
  389. #define        (kMaxClumpsPerForest,              3)
  390.  
  391.  
  392. #elif Is5Players
  393. //////////////////////////////////////////////////////////////////////
  394. // 5 PLAYERS...
  395. //////////////////////////////////////////////////////////////////////
  396.  
  397. ResourceSeperation    5 
  398.  
  399. //////////////////////////////////////////////////////////////////////
  400. // terrain definitions
  401. #define        (kMinIntElevation,            -8)
  402.  
  403. #if        PERCENT(80)
  404.   #define        (kMaxIntElevation,             8)
  405. #else
  406.   #define        (kMaxIntElevation,            15)
  407. #endif 
  408.  
  409. #define        (kElevationScale,                1)
  410. #define        (kPercentLand,                Between(.84, .84))
  411. #define        (kWaterBorder,                0)
  412. #define        (kHeightMapChaos,                Between(10, 14))
  413.                                             
  414. #define        (kMinimumStartPositionToMapEdge    4)
  415. #define        (kOuterPushFromMapCenter        34)
  416. #define        (kInnerPushFromMapCenter         24)
  417.  
  418. #define        (kConvergentSampleSize,            32) 
  419. #define        (kConvergentThreshold,            1)
  420.  
  421. //////////////////////////////////////////////////////////////////////
  422. // player definitions
  423. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  424. #define        (kPlayerInnerRadius,            0.6)
  425. #define        (kPlayerOuterRadius,            0.99)
  426. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  427. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  428. #define        (kPlayerLandChaos,            0.8)
  429. #define        (kPlayerLandClumps,            1)
  430. #define        (kPlayerFlatChaos,            0.8)
  431. #define        (kPlayerFlatClumps,            2)
  432. #define        (kPlayerTreePercentage,            0.04)
  433.  
  434.  
  435. //////////////////////////////////////////////////////////////////////
  436. // inner neutral definitions
  437. #define        (kNeutralInnerRadius,            0.45)
  438. #define        (kNeutralOuterRadius,            0.45)
  439. #define        (kNeutralOptimalFactor,            0.7)
  440. #define        (kNumInnerNeutrals,            Between(16, 16))
  441. #define        (kInnerNeutralPercentLand,        0.19)
  442. #define        (kInnerNeutralPercentFlat,        Between(.9, .9))
  443. #define        (kInnerNeutralTreePercentage,          0.35)
  444. #define        (kInnerNeutralLandChaos,        0.9)
  445. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  446. #define        (kInnerNeutralFlatChaos,        0.8)
  447. #define        (kInnerNeutralFlatClumps,        1)
  448.  
  449.  
  450. //////////////////////////////////////////////////////////////////////
  451. // outer neutral definitions
  452. #define        (kNumOuterNeutrals,            20)
  453. #define        (kOuterNeutralPercentLand,        0.60)
  454. #define        (kOuterNeutralPercentFlat,        Between(.9, .9))
  455. #define        (kOuterNeutralTreePercentage,          0.15)
  456. #define        (kOuterNeutralLandChaos,        0.8)
  457. #define        (kOuterNeutralLandClumps,        1)
  458. #define        (kOuterNeutralFlatChaos,        0.8)
  459. #define        (kOuterNeutralFlatClumps,        1)
  460.  
  461.  
  462. //////////////////////////////////////////////////////////////////////
  463. // resource definitions
  464. #define        (kMaxResourceElevation,            3)
  465. #define        (kResourceToEdgeDistance,        1)
  466. #define        (kResourceToWaterDistance,        3)
  467.  
  468. #define        (kAnimalPerPlayer,            0)
  469. #define        (kAnimalPerNeutral,            0)
  470.  
  471. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  472.   #define  (kBerryPerPlayer,    2) 
  473.   #define  (kBerryPerNeutral,      0)
  474. #else
  475.   #define  (kBerryPerPlayer,    1)
  476.   #define  (kBerryPerNeutral,      0)
  477. #endif 
  478.  
  479. #define        (kFishPerPlayer,                0)
  480. #define        (kFishPerNeutral,                60)
  481.  
  482. #define        (kGoldPerPlayer,                1)
  483. #define        (kGoldPerNeutral,                14)
  484.  
  485. #define        (kOilPerPlayer,                0)
  486. #define        (kOilPerNeutral,                0)
  487.  
  488. #define        (kSteelPerPlayer,                1)
  489. #define        (kSteelPerNeutral,            14)
  490.  
  491. #define        (kStonePerPlayer,                1)
  492. #define        (kStonePerNeutral,            5)
  493.  
  494. #define        (kTreePerPlayer,                2)
  495. #define        (kTreePerNeutral,                0)
  496.  
  497.  
  498. //////////////////////////////////////////////////////////////////////
  499. // forest definitions
  500. #define        (kForestFreeRadius,            9.0)
  501. #define        (kForestsPerPlayer,            1)
  502. #define        (kForestChaosLevel,            .01)
  503. #define        (kMaxClumpsPerForest,              3)
  504.  
  505. #elif Is6Players
  506. //////////////////////////////////////////////////////////////////////
  507. // 6 PLAYERS...
  508. //////////////////////////////////////////////////////////////////////
  509.  
  510. ResourceSeperation    5 
  511.  
  512. //////////////////////////////////////////////////////////////////////
  513. // terrain definitions
  514. #define        (kMinIntElevation,            -8)
  515.  
  516. #if        PERCENT(80)
  517.   #define        (kMaxIntElevation,             8)
  518. #else
  519.   #define        (kMaxIntElevation,            15)
  520. #endif 
  521.  
  522. #define        (kElevationScale,                1)
  523. #define        (kPercentLand,                Between(.82, .82))
  524. #define        (kWaterBorder,                0)
  525. #define        (kHeightMapChaos,                Between(10, 14))
  526.                                             
  527. #define        (kMinimumStartPositionToMapEdge    4)
  528. #define        (kOuterPushFromMapCenter        34)
  529. #define        (kInnerPushFromMapCenter         24)    
  530.  
  531. #define        (kConvergentSampleSize,            32) 
  532. #define        (kConvergentThreshold,            1)            
  533.  
  534. //////////////////////////////////////////////////////////////////////
  535. // player definitions
  536. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  537. #define        (kPlayerInnerRadius,            0.6)
  538. #define        (kPlayerOuterRadius,            0.99)
  539. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  540. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  541. #define        (kPlayerLandChaos,            0.8)
  542. #define        (kPlayerLandClumps,            1)
  543. #define        (kPlayerFlatChaos,            0.8)
  544. #define        (kPlayerFlatClumps,            2)
  545. #define        (kPlayerTreePercentage,            0.03)
  546.  
  547.  
  548. //////////////////////////////////////////////////////////////////////
  549. // inner neutral definitions
  550. #define        (kNeutralInnerRadius,            0.45)
  551. #define        (kNeutralOuterRadius,            0.45)
  552. #define        (kNeutralOptimalFactor,            0.7)
  553. #define        (kNumInnerNeutrals,            Between(14, 14))
  554. #define        (kInnerNeutralPercentLand,        0.2)
  555. #define        (kInnerNeutralPercentFlat,        Between(.9, .9))
  556. #define        (kInnerNeutralTreePercentage,          0.35)
  557. #define        (kInnerNeutralLandChaos,        0.9)
  558. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  559. #define        (kInnerNeutralFlatChaos,        0.8)
  560. #define        (kInnerNeutralFlatClumps,        1)
  561.  
  562.  
  563. //////////////////////////////////////////////////////////////////////
  564. // outer neutral definitions
  565. #define        (kNumOuterNeutrals,            18)
  566. #define        (kOuterNeutralPercentLand,        0.55)
  567. #define        (kOuterNeutralPercentFlat,        Between(.9, .9))
  568. #define        (kOuterNeutralTreePercentage,          0.15)
  569. #define        (kOuterNeutralLandChaos,        0.8)
  570. #define        (kOuterNeutralLandClumps,        1)
  571. #define        (kOuterNeutralFlatChaos,        0.8)
  572. #define        (kOuterNeutralFlatClumps,        1)
  573.  
  574.  
  575. //////////////////////////////////////////////////////////////////////
  576. // resource definitions
  577. #define        (kMaxResourceElevation,            3)
  578. #define        (kResourceToEdgeDistance,        1)
  579. #define        (kResourceToWaterDistance,        3)
  580.  
  581. #define        (kAnimalPerPlayer,            0)
  582. #define        (kAnimalPerNeutral,            0)
  583.  
  584. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  585.   #define  (kBerryPerPlayer,    2) 
  586.   #define  (kBerryPerNeutral,      0)
  587. #else
  588.   #define  (kBerryPerPlayer,    1)
  589.   #define  (kBerryPerNeutral,      0)
  590. #endif 
  591.  
  592. #define        (kFishPerPlayer,                0)
  593. #define        (kFishPerNeutral,                60)
  594.  
  595. #define        (kGoldPerPlayer,                1)
  596. #define        (kGoldPerNeutral,                17)
  597.  
  598. #define        (kOilPerPlayer,                0)
  599. #define        (kOilPerNeutral,                0)
  600.  
  601. #define        (kSteelPerPlayer,                1)
  602. #define        (kSteelPerNeutral,            17)
  603.  
  604. #define        (kStonePerPlayer,                1)
  605. #define        (kStonePerNeutral,            6)
  606.  
  607. #define        (kTreePerPlayer,                2)
  608. #define        (kTreePerNeutral,                0)
  609.  
  610.  
  611. //////////////////////////////////////////////////////////////////////
  612. // forest definitions
  613. #define        (kForestFreeRadius,            9.0)
  614. #define        (kForestsPerPlayer,            1)
  615. #define        (kForestChaosLevel,            .1)
  616. #define        (kMaxClumpsPerForest,              3)
  617.  
  618.  
  619. #elif Is7Players
  620. //////////////////////////////////////////////////////////////////////
  621. // 7 PLAYERS...
  622. //////////////////////////////////////////////////////////////////////
  623.  
  624. ResourceSeperation    5 
  625.  
  626. //////////////////////////////////////////////////////////////////////
  627. // terrain definitions
  628. #define        (kMinIntElevation,            -8)
  629.  
  630. #if        PERCENT(80)
  631.   #define        (kMaxIntElevation,             8)
  632. #else
  633.   #define        (kMaxIntElevation,            15)
  634. #endif 
  635.  
  636. #define        (kElevationScale,                1)
  637. #define        (kPercentLand,                Between(.76, .76))
  638. #define        (kWaterBorder,                0)
  639. #define        (kHeightMapChaos,                Between(10, 14))
  640.                                             
  641. #define        (kMinimumStartPositionToMapEdge    4)
  642. #define        (kOuterPushFromMapCenter        34)
  643. #define        (kInnerPushFromMapCenter         24)
  644.  
  645. #define        (kConvergentSampleSize,            32) 
  646. #define        (kConvergentThreshold,            1)
  647.  
  648. //////////////////////////////////////////////////////////////////////
  649. // player definitions
  650. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  651. #define        (kPlayerInnerRadius,            0.6)
  652. #define        (kPlayerOuterRadius,            0.99)
  653. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  654. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  655. #define        (kPlayerLandChaos,            0.8)
  656. #define        (kPlayerLandClumps,            1)
  657. #define        (kPlayerFlatChaos,            0.8)
  658. #define        (kPlayerFlatClumps,            2)
  659. #define        (kPlayerTreePercentage,            0.03)
  660.  
  661.  
  662. //////////////////////////////////////////////////////////////////////
  663. // inner neutral definitions
  664. #define        (kNeutralInnerRadius,            0.45)
  665. #define        (kNeutralOuterRadius,            0.45)
  666. #define        (kNeutralOptimalFactor,            0.7)
  667. #define        (kNumInnerNeutrals,            Between(13, 13))
  668. #define        (kInnerNeutralPercentLand,        0.17)
  669. #define        (kInnerNeutralPercentFlat,        Between(.9, .9))
  670. #define        (kInnerNeutralTreePercentage,          0.35)
  671. #define        (kInnerNeutralLandChaos,        0.9)
  672. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  673. #define        (kInnerNeutralFlatChaos,        0.8)
  674. #define        (kInnerNeutralFlatClumps,        1)
  675.  
  676. //////////////////////////////////////////////////////////////////////
  677. // outer neutral definitions
  678. #define        (kNumOuterNeutrals,            16)
  679. #define        (kOuterNeutralPercentLand,        0.4)
  680. #define        (kOuterNeutralPercentFlat,        Between(.9, .9))
  681. #define        (kOuterNeutralTreePercentage,          0.15)
  682. #define        (kOuterNeutralLandChaos,        0.8)
  683. #define        (kOuterNeutralLandClumps,        1)
  684. #define        (kOuterNeutralFlatChaos,        0.8)
  685. #define        (kOuterNeutralFlatClumps,        1)
  686.  
  687. //////////////////////////////////////////////////////////////////////
  688. // resource definitions
  689. #define        (kMaxResourceElevation,            3)
  690. #define        (kResourceToEdgeDistance,        1)
  691. #define        (kResourceToWaterDistance,        3)
  692.  
  693. #define        (kAnimalPerPlayer,            0)
  694. #define        (kAnimalPerNeutral,            0)
  695.  
  696. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  697.   #define  (kBerryPerPlayer,    2) 
  698.   #define  (kBerryPerNeutral,      0)
  699. #else
  700.   #define  (kBerryPerPlayer,    1)
  701.   #define  (kBerryPerNeutral,      0)
  702. #endif 
  703.  
  704. #define        (kFishPerPlayer,                0)
  705. #define        (kFishPerNeutral,                60)
  706.  
  707. #define        (kGoldPerPlayer,                2)
  708. #define        (kGoldPerNeutral,                11)
  709.  
  710. #define        (kOilPerPlayer,                0)
  711. #define        (kOilPerNeutral,                0)
  712.  
  713. #define        (kSteelPerPlayer,                2)
  714. #define        (kSteelPerNeutral,            11)
  715.  
  716. #define        (kStonePerPlayer,                1)
  717. #define        (kStonePerNeutral,            7)
  718.  
  719. #define        (kTreePerPlayer,                2)
  720. #define        (kTreePerNeutral,                0)
  721.  
  722.  
  723. //////////////////////////////////////////////////////////////////////
  724. // forest definitions
  725. #define        (kForestFreeRadius,            9.0)
  726. #define        (kForestsPerPlayer,            1)
  727. #define        (kForestChaosLevel,            .1)
  728. #define        (kMaxClumpsPerForest,              3)
  729.  
  730.  
  731. #elif Is8Players
  732. //////////////////////////////////////////////////////////////////////
  733. // 8 PLAYERS...
  734. //////////////////////////////////////////////////////////////////////
  735.  
  736. ResourceSeperation    5 
  737.  
  738. //////////////////////////////////////////////////////////////////////
  739. // terrain definitions
  740. #define        (kMinIntElevation,            -8)
  741.  
  742. #if        PERCENT(80)
  743.   #define        (kMaxIntElevation,             8)
  744. #else
  745.   #define        (kMaxIntElevation,            15)
  746. #endif 
  747.  
  748. #define        (kElevationScale,                1)
  749. #define        (kPercentLand,                Between(.7, .7))
  750. #define        (kWaterBorder,                0)
  751. #define        (kHeightMapChaos,                Between(10, 14))
  752.                                             
  753. #define        (kMinimumStartPositionToMapEdge    4)
  754. #define        (kOuterPushFromMapCenter        34)
  755. #define        (kInnerPushFromMapCenter         24)        
  756.  
  757. #define        (kConvergentSampleSize,            32) 
  758. #define        (kConvergentThreshold,            1)                                
  759. //////////////////////////////////////////////////////////////////////
  760. // player definitions
  761. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  762. #define        (kPlayerInnerRadius,            0.7)
  763. #define        (kPlayerOuterRadius,            0.99)
  764. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  765. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  766. #define        (kPlayerLandChaos,            0.8)
  767. #define        (kPlayerLandClumps,            1)
  768. #define        (kPlayerFlatChaos,            0.8)
  769. #define        (kPlayerFlatClumps,            1)
  770. #define        (kPlayerTreePercentage,            0.03)
  771.  
  772.  
  773. //////////////////////////////////////////////////////////////////////
  774. // inner neutral definitions
  775. #define        (kNeutralInnerRadius,            0.45)
  776. #define        (kNeutralOuterRadius,            0.45)
  777. #define        (kNeutralOptimalFactor,            0.7)
  778. #define        (kNumInnerNeutrals,            Between(12, 12))
  779. #define        (kInnerNeutralPercentLand,        0.15)
  780. #define        (kInnerNeutralPercentFlat,        Between(.9, .9))
  781. #define        (kInnerNeutralTreePercentage,          0.35)
  782. #define        (kInnerNeutralLandChaos,        0.9)
  783. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  784. #define        (kInnerNeutralFlatChaos,        0.8)
  785. #define        (kInnerNeutralFlatClumps,        1)
  786.  
  787.  
  788. //////////////////////////////////////////////////////////////////////
  789. // outer neutral definitions
  790. #define        (kNumOuterNeutrals,            15)
  791. #define        (kOuterNeutralPercentLand,        0.35)
  792. #define        (kOuterNeutralPercentFlat,        Between(.9, .9))
  793. #define        (kOuterNeutralTreePercentage,          0.15)
  794. #define        (kOuterNeutralLandChaos,        0.8)
  795. #define        (kOuterNeutralLandClumps,        1)
  796. #define        (kOuterNeutralFlatChaos,        0.8)
  797. #define        (kOuterNeutralFlatClumps,        1)
  798.  
  799.  
  800. //////////////////////////////////////////////////////////////////////
  801. // resource definitions
  802. #define        (kMaxResourceElevation,            3)
  803. #define        (kResourceToEdgeDistance,        1)
  804. #define        (kResourceToWaterDistance,        3)
  805.  
  806. #define        (kAnimalPerPlayer,            0)
  807. #define        (kAnimalPerNeutral,            0)
  808.  
  809. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  810.   #define  (kBerryPerPlayer,    2) 
  811.   #define  (kBerryPerNeutral,      0)
  812. #else
  813.   #define  (kBerryPerPlayer,    1)
  814.   #define  (kBerryPerNeutral,      0)
  815. #endif 
  816.  
  817. #define        (kFishPerPlayer,                0)
  818. #define        (kFishPerNeutral,                60)
  819.  
  820. #define        (kGoldPerPlayer,                2)
  821. #define        (kGoldPerNeutral,                10)
  822.  
  823. #define        (kOilPerPlayer,                0)
  824. #define        (kOilPerNeutral,                0)
  825.  
  826. #define        (kSteelPerPlayer,                2)
  827. #define        (kSteelPerNeutral,            10)
  828.  
  829. #define        (kStonePerPlayer,                1)
  830. #define        (kStonePerNeutral,            6)
  831.  
  832. #define        (kTreePerPlayer,                2)
  833. #define        (kTreePerNeutral,                0)
  834.  
  835.  
  836. //////////////////////////////////////////////////////////////////////
  837. // forest definitions
  838. #define        (kForestFreeRadius,            9.0)
  839. #define        (kForestsPerPlayer,            1)
  840. #define        (kForestChaosLevel,            .01)
  841. #define        (kMaxClumpsPerForest,              3)
  842.  
  843.  
  844. #elif Is9Players
  845. //////////////////////////////////////////////////////////////////////
  846. // 9 PLAYERS...
  847. //////////////////////////////////////////////////////////////////////
  848.  
  849. //////////////////////////////////////////////////////////////////////
  850. // terrain definitions
  851. #define        (kMinIntElevation,            -10)
  852. #define        (kMaxIntElevation,            10)
  853. #define        (kElevationScale,                0.99)
  854. #define        (kPercentLand,                Between(.88, .88))
  855. #define        (kWaterBorder,                0)
  856. #define        (kHeightMapChaos,                Between(10, 20))
  857.  
  858. #define        (kMinimumStartPositionToMapEdge    4)
  859. #define        (kOuterPushFromMapCenter        24)
  860. #define        (kInnerPushFromMapCenter         0)                                            
  861. //////////////////////////////////////////////////////////////////////
  862. // player definitions
  863. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  864. #define        (kPlayerInnerRadius,            0.7)
  865. #define        (kPlayerOuterRadius,            0.99)
  866. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  867. #define        (kPlayerPercentFlat,            Between(0.6, 0.6))
  868. #define        (kPlayerLandChaos,            0.8)
  869. #define        (kPlayerLandClumps,            1)
  870. #define        (kPlayerFlatChaos,            0.8)
  871. #define        (kPlayerFlatClumps,            2)
  872. #define        (kPlayerTreePercentage,            0.03)
  873.  
  874.  
  875. //////////////////////////////////////////////////////////////////////
  876. // inner neutral definitions
  877. #define        (kNeutralInnerRadius,            0.45)
  878. #define        (kNeutralOuterRadius,            0.45)
  879. #define        (kNeutralOptimalFactor,            0.7)
  880. #define        (kNumInnerNeutrals,            Between(3, 3))
  881. #define        (kInnerNeutralPercentLand,        0.1)
  882. #define        (kInnerNeutralPercentFlat,        Between(.8, .8))
  883. #define        (kInnerNeutralTreePercentage,          0.12)
  884. #define        (kInnerNeutralLandChaos,        0.9)
  885. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  886. #define        (kInnerNeutralFlatChaos,        0.8)
  887. #define        (kInnerNeutralFlatClumps,        1)
  888.  
  889.  
  890. //////////////////////////////////////////////////////////////////////
  891. // outer neutral definitions
  892. #define        (kNumOuterNeutrals,            22)
  893. #define        (kOuterNeutralPercentLand,        0.6)
  894. #define        (kOuterNeutralPercentFlat,        Between(.6, .8))
  895. #define        (kOuterNeutralTreePercentage,          0.07)
  896. #define        (kOuterNeutralLandChaos,        0.8)
  897. #define        (kOuterNeutralLandClumps,        2)
  898. #define        (kOuterNeutralFlatChaos,        0.8)
  899. #define        (kOuterNeutralFlatClumps,        1)
  900.  
  901.  
  902. //////////////////////////////////////////////////////////////////////
  903. // resource definitions
  904. #define        (kMaxResourceElevation,            3)
  905. #define        (kResourceToEdgeDistance,        3)
  906. #define        (kResourceToWaterDistance,        3)
  907.  
  908. #define        (kAnimalPerPlayer,            0)
  909. #define        (kAnimalPerNeutral,            0)
  910.  
  911. #define        (kBerryPerPlayer,                1)
  912. #define        (kBerryPerNeutral,            0)
  913.  
  914. #define        (kFishPerPlayer,                0)
  915. #define        (kFishPerNeutral,                60)
  916.  
  917. #define        (kGoldPerPlayer,                2)
  918. #define        (kGoldPerNeutral,                2)
  919.  
  920. #define        (kOilPerPlayer,                0)
  921. #define        (kOilPerNeutral,                0)
  922.  
  923. #define        (kSteelPerPlayer,                2)
  924. #define        (kSteelPerNeutral,            2)
  925.  
  926. #define        (kStonePerPlayer,                1)
  927. #define        (kStonePerNeutral,            6)
  928.  
  929. #define        (kTreePerPlayer,                0)
  930. #define        (kTreePerNeutral,                0)
  931.  
  932.  
  933. //////////////////////////////////////////////////////////////////////
  934. // forest definitions
  935. #define        (kForestFreeRadius,            9.0)
  936. #define        (kForestsPerPlayer,            2)
  937. #define        (kForestChaosLevel,            0.1)
  938. #define        (kMaxClumpsPerForest,              3)
  939.  
  940.  
  941. #elif Is10Players
  942. //////////////////////////////////////////////////////////////////////
  943. // 10 PLAYERS...
  944. //////////////////////////////////////////////////////////////////////
  945.  
  946. //////////////////////////////////////////////////////////////////////
  947. // terrain definitions
  948. #define        (kMinIntElevation,            -10)
  949. #define        (kMaxIntElevation,            10)
  950. #define        (kElevationScale,                0.99)
  951. #define        (kPercentLand,                Between(.88, .88))
  952. #define        (kWaterBorder,                0)
  953. #define        (kHeightMapChaos,                Between(10, 20))
  954.  
  955. #define        (kMinimumStartPositionToMapEdge    4)
  956. #define        (kOuterPushFromMapCenter        24)
  957. #define        (kInnerPushFromMapCenter         0)                                            
  958. //////////////////////////////////////////////////////////////////////
  959. // player definitions
  960. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  961. #define        (kPlayerInnerRadius,            0.7)
  962. #define        (kPlayerOuterRadius,            0.99)
  963. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  964. #define        (kPlayerPercentFlat,            Between(0.6, 0.6))
  965. #define        (kPlayerLandChaos,            0.8)
  966. #define        (kPlayerLandClumps,            1)
  967. #define        (kPlayerFlatChaos,            0.8)
  968. #define        (kPlayerFlatClumps,            2)
  969. #define        (kPlayerTreePercentage,            0.03)
  970.  
  971.  
  972. //////////////////////////////////////////////////////////////////////
  973. // inner neutral definitions
  974. #define        (kNeutralInnerRadius,            0.45)
  975. #define        (kNeutralOuterRadius,            0.45)
  976. #define        (kNeutralOptimalFactor,            0.7)
  977. #define        (kNumInnerNeutrals,            Between(3, 3))
  978. #define        (kInnerNeutralPercentLand,        0.1)
  979. #define        (kInnerNeutralPercentFlat,        Between(.8, .8))
  980. #define        (kInnerNeutralTreePercentage,          0.12)
  981. #define        (kInnerNeutralLandChaos,        0.9)
  982. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  983. #define        (kInnerNeutralFlatChaos,        0.8)
  984. #define        (kInnerNeutralFlatClumps,        1)
  985.  
  986.  
  987. //////////////////////////////////////////////////////////////////////
  988. // outer neutral definitions
  989. #define        (kNumOuterNeutrals,            22)
  990. #define        (kOuterNeutralPercentLand,        0.6)
  991. #define        (kOuterNeutralPercentFlat,        Between(.6, .8))
  992. #define        (kOuterNeutralTreePercentage,          0.07)
  993. #define        (kOuterNeutralLandChaos,        0.8)
  994. #define        (kOuterNeutralLandClumps,        2)
  995. #define        (kOuterNeutralFlatChaos,        0.8)
  996. #define        (kOuterNeutralFlatClumps,        1)
  997.  
  998.  
  999. //////////////////////////////////////////////////////////////////////
  1000. // resource definitions
  1001. #define        (kMaxResourceElevation,            3)
  1002. #define        (kResourceToEdgeDistance,        3)
  1003. #define        (kResourceToWaterDistance,        3)
  1004.  
  1005. #define        (kAnimalPerPlayer,            0)
  1006. #define        (kAnimalPerNeutral,            0)
  1007.  
  1008. #define        (kBerryPerPlayer,                1)
  1009. #define        (kBerryPerNeutral,            0)
  1010.  
  1011. #define        (kFishPerPlayer,                0)
  1012. #define        (kFishPerNeutral,                60)
  1013.  
  1014. #define        (kGoldPerPlayer,                2)
  1015. #define        (kGoldPerNeutral,                2)
  1016.  
  1017. #define        (kOilPerPlayer,                0)
  1018. #define        (kOilPerNeutral,                0)
  1019.  
  1020. #define        (kSteelPerPlayer,                2)
  1021. #define        (kSteelPerNeutral,            2)
  1022.  
  1023. #define        (kStonePerPlayer,                1)
  1024. #define        (kStonePerNeutral,            6)
  1025.  
  1026. #define        (kTreePerPlayer,                0)
  1027. #define        (kTreePerNeutral,                0)
  1028.  
  1029.  
  1030. //////////////////////////////////////////////////////////////////////
  1031. // forest definitions
  1032. #define        (kForestFreeRadius,            9.0)
  1033. #define        (kForestsPerPlayer,            2)
  1034. #define        (kForestChaosLevel,            0.9)
  1035. #define        (kMaxClumpsPerForest,              2)
  1036.  
  1037.  
  1038. #elif Is11Players
  1039. //////////////////////////////////////////////////////////////////////
  1040. // 11 PLAYERS...
  1041. //////////////////////////////////////////////////////////////////////
  1042.  
  1043. //////////////////////////////////////////////////////////////////////
  1044. // terrain definitions
  1045. #define        (kMinIntElevation,            -10)
  1046. #define        (kMaxIntElevation,            10)
  1047. #define        (kElevationScale,                0.99)
  1048. #define        (kPercentLand,                Between(.88, .88))
  1049. #define        (kWaterBorder,                0)
  1050. #define        (kHeightMapChaos,                Between(10, 20))
  1051.  
  1052. #define        (kMinimumStartPositionToMapEdge    4)
  1053. #define        (kOuterPushFromMapCenter        24)
  1054. #define        (kInnerPushFromMapCenter         0)                                            
  1055. //////////////////////////////////////////////////////////////////////
  1056. // player definitions
  1057. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  1058. #define        (kPlayerInnerRadius,            0.7)
  1059. #define        (kPlayerOuterRadius,            0.99)
  1060. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1061. #define        (kPlayerPercentFlat,            Between(0.6, 0.6))
  1062. #define        (kPlayerLandChaos,            0.8)
  1063. #define        (kPlayerLandClumps,            1)
  1064. #define        (kPlayerFlatChaos,            0.8)
  1065. #define        (kPlayerFlatClumps,            2)
  1066. #define        (kPlayerTreePercentage,            0.03)
  1067.  
  1068.  
  1069. //////////////////////////////////////////////////////////////////////
  1070. // inner neutral definitions
  1071. #define        (kNeutralInnerRadius,            0.45)
  1072. #define        (kNeutralOuterRadius,            0.45)
  1073. #define        (kNeutralOptimalFactor,            0.7)
  1074. #define        (kNumInnerNeutrals,            Between(3, 3))
  1075. #define        (kInnerNeutralPercentLand,        0.1)
  1076. #define        (kInnerNeutralPercentFlat,        Between(.8, .8))
  1077. #define        (kInnerNeutralTreePercentage,          0.12)
  1078. #define        (kInnerNeutralLandChaos,        0.9)
  1079. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1080. #define        (kInnerNeutralFlatChaos,        0.8)
  1081. #define        (kInnerNeutralFlatClumps,        1)
  1082.  
  1083.  
  1084. //////////////////////////////////////////////////////////////////////
  1085. // outer neutral definitions
  1086. #define        (kNumOuterNeutrals,            22)
  1087. #define        (kOuterNeutralPercentLand,        0.6)
  1088. #define        (kOuterNeutralPercentFlat,        Between(.6, .8))
  1089. #define        (kOuterNeutralTreePercentage,          0.07)
  1090. #define        (kOuterNeutralLandChaos,        0.8)
  1091. #define        (kOuterNeutralLandClumps,        2)
  1092. #define        (kOuterNeutralFlatChaos,        0.8)
  1093. #define        (kOuterNeutralFlatClumps,        1)
  1094.  
  1095.  
  1096. //////////////////////////////////////////////////////////////////////
  1097. // resource definitions
  1098. #define        (kMaxResourceElevation,            3)
  1099. #define        (kResourceToEdgeDistance,        3)
  1100. #define        (kResourceToWaterDistance,        3)
  1101.  
  1102. #define        (kAnimalPerPlayer,            0)
  1103. #define        (kAnimalPerNeutral,            0)
  1104.  
  1105. #define        (kBerryPerPlayer,                1)
  1106. #define        (kBerryPerNeutral,            0)
  1107.  
  1108. #define        (kFishPerPlayer,                0)
  1109. #define        (kFishPerNeutral,                60)
  1110.  
  1111. #define        (kGoldPerPlayer,                2)
  1112. #define        (kGoldPerNeutral,                2)
  1113.  
  1114. #define        (kOilPerPlayer,                0)
  1115. #define        (kOilPerNeutral,                0)
  1116.  
  1117. #define        (kSteelPerPlayer,                2)
  1118. #define        (kSteelPerNeutral,            2)
  1119.  
  1120. #define        (kStonePerPlayer,                1)
  1121. #define        (kStonePerNeutral,            6)
  1122.  
  1123. #define        (kTreePerPlayer,                0)
  1124. #define        (kTreePerNeutral,                0)
  1125.  
  1126.  
  1127. //////////////////////////////////////////////////////////////////////
  1128. // forest definitions
  1129. #define        (kForestFreeRadius,            9.0)
  1130. #define        (kForestsPerPlayer,            2)
  1131. #define        (kForestChaosLevel,            0.9)
  1132. #define        (kMaxClumpsPerForest,              2)
  1133.  
  1134.  
  1135. #elif Is12Players
  1136. //////////////////////////////////////////////////////////////////////
  1137. // 12 PLAYERS...
  1138. //////////////////////////////////////////////////////////////////////
  1139.  
  1140. //////////////////////////////////////////////////////////////////////
  1141. // terrain definitions
  1142. #define        (kMinIntElevation,            -10)
  1143. #define        (kMaxIntElevation,            10)
  1144. #define        (kElevationScale,                0.99)
  1145. #define        (kPercentLand,                Between(.88, .88))
  1146. #define        (kWaterBorder,                0)
  1147. #define        (kHeightMapChaos,                Between(10, 20))
  1148.  
  1149. #define        (kMinimumStartPositionToMapEdge    4)
  1150. #define        (kOuterPushFromMapCenter        24)
  1151. #define        (kInnerPushFromMapCenter         0)                                            
  1152. //////////////////////////////////////////////////////////////////////
  1153. // player definitions
  1154. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  1155. #define        (kPlayerInnerRadius,            0.7)
  1156. #define        (kPlayerOuterRadius,            0.99)
  1157. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1158. #define        (kPlayerPercentFlat,            Between(0.6, 0.6))
  1159. #define        (kPlayerLandChaos,            0.8)
  1160. #define        (kPlayerLandClumps,            1)
  1161. #define        (kPlayerFlatChaos,            0.8)
  1162. #define        (kPlayerFlatClumps,            2)
  1163. #define        (kPlayerTreePercentage,            0.03)
  1164.  
  1165.  
  1166. //////////////////////////////////////////////////////////////////////
  1167. // inner neutral definitions
  1168. #define        (kNeutralInnerRadius,            0.45)
  1169. #define        (kNeutralOuterRadius,            0.45)
  1170. #define        (kNeutralOptimalFactor,            0.7)
  1171. #define        (kNumInnerNeutrals,            Between(3, 3))
  1172. #define        (kInnerNeutralPercentLand,        0.1)
  1173. #define        (kInnerNeutralPercentFlat,        Between(.8, .8))
  1174. #define        (kInnerNeutralTreePercentage,          0.12)
  1175. #define        (kInnerNeutralLandChaos,        0.9)
  1176. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1177. #define        (kInnerNeutralFlatChaos,        0.8)
  1178. #define        (kInnerNeutralFlatClumps,        1)
  1179.  
  1180.  
  1181. //////////////////////////////////////////////////////////////////////
  1182. // outer neutral definitions
  1183. #define        (kNumOuterNeutrals,            22)
  1184. #define        (kOuterNeutralPercentLand,        0.6)
  1185. #define        (kOuterNeutralPercentFlat,        Between(.6, .8))
  1186. #define        (kOuterNeutralTreePercentage,          0.07)
  1187. #define        (kOuterNeutralLandChaos,        0.8)
  1188. #define        (kOuterNeutralLandClumps,        2)
  1189. #define        (kOuterNeutralFlatChaos,        0.8)
  1190. #define        (kOuterNeutralFlatClumps,        1)
  1191.  
  1192.  
  1193. //////////////////////////////////////////////////////////////////////
  1194. // resource definitions
  1195. #define        (kMaxResourceElevation,            3)
  1196. #define        (kResourceToEdgeDistance,        3)
  1197. #define        (kResourceToWaterDistance,        3)
  1198.  
  1199. #define        (kAnimalPerPlayer,            0)
  1200. #define        (kAnimalPerNeutral,            0)
  1201.  
  1202. #define        (kBerryPerPlayer,                1)
  1203. #define        (kBerryPerNeutral,            0)
  1204.  
  1205. #define        (kFishPerPlayer,                0)
  1206. #define        (kFishPerNeutral,                60)
  1207.  
  1208. #define        (kGoldPerPlayer,                2)
  1209. #define        (kGoldPerNeutral,                2)
  1210.  
  1211. #define        (kOilPerPlayer,                0)
  1212. #define        (kOilPerNeutral,                0)
  1213.  
  1214. #define        (kSteelPerPlayer,                2)
  1215. #define        (kSteelPerNeutral,            2)
  1216.  
  1217. #define        (kStonePerPlayer,                1)
  1218. #define        (kStonePerNeutral,            6)
  1219.  
  1220. #define        (kTreePerPlayer,                0)
  1221. #define        (kTreePerNeutral,                0)
  1222.  
  1223.  
  1224. //////////////////////////////////////////////////////////////////////
  1225. // forest definitions
  1226. #define        (kForestFreeRadius,            9.0)
  1227. #define        (kForestsPerPlayer,            2)
  1228. #define        (kForestChaosLevel,            0.9)
  1229. #define        (kMaxClumpsPerForest,              2)
  1230.  
  1231.  
  1232. #elif Is13Players
  1233. //////////////////////////////////////////////////////////////////////
  1234. // 13 PLAYERS...
  1235. //////////////////////////////////////////////////////////////////////
  1236.  
  1237. //////////////////////////////////////////////////////////////////////
  1238. // terrain definitions
  1239. #define        (kMinIntElevation,            -10)
  1240. #define        (kMaxIntElevation,            10)
  1241. #define        (kElevationScale,                0.99)
  1242. #define        (kPercentLand,                Between(.88, .88))
  1243. #define        (kWaterBorder,                0)
  1244. #define        (kHeightMapChaos,                Between(10, 20))
  1245.  
  1246. #define        (kMinimumStartPositionToMapEdge    4)
  1247. #define        (kOuterPushFromMapCenter        24)
  1248. #define        (kInnerPushFromMapCenter         0)                                            
  1249. //////////////////////////////////////////////////////////////////////
  1250. // player definitions
  1251. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  1252. #define        (kPlayerInnerRadius,            0.7)
  1253. #define        (kPlayerOuterRadius,            0.99)
  1254. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1255. #define        (kPlayerPercentFlat,            Between(0.6, 0.6))
  1256. #define        (kPlayerLandChaos,            0.8)
  1257. #define        (kPlayerLandClumps,            1)
  1258. #define        (kPlayerFlatChaos,            0.8)
  1259. #define        (kPlayerFlatClumps,            2)
  1260. #define        (kPlayerTreePercentage,            0.03)
  1261.  
  1262.  
  1263. //////////////////////////////////////////////////////////////////////
  1264. // inner neutral definitions
  1265. #define        (kNeutralInnerRadius,            0.45)
  1266. #define        (kNeutralOuterRadius,            0.45)
  1267. #define        (kNeutralOptimalFactor,            0.7)
  1268. #define        (kNumInnerNeutrals,            Between(3, 3))
  1269. #define        (kInnerNeutralPercentLand,        0.1)
  1270. #define        (kInnerNeutralPercentFlat,        Between(.8, .8))
  1271. #define        (kInnerNeutralTreePercentage,          0.12)
  1272. #define        (kInnerNeutralLandChaos,        0.9)
  1273. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1274. #define        (kInnerNeutralFlatChaos,        0.8)
  1275. #define        (kInnerNeutralFlatClumps,        1)
  1276.  
  1277.  
  1278. //////////////////////////////////////////////////////////////////////
  1279. // outer neutral definitions
  1280. #define        (kNumOuterNeutrals,            22)
  1281. #define        (kOuterNeutralPercentLand,        0.6)
  1282. #define        (kOuterNeutralPercentFlat,        Between(.6, .8))
  1283. #define        (kOuterNeutralTreePercentage,          0.07)
  1284. #define        (kOuterNeutralLandChaos,        0.8)
  1285. #define        (kOuterNeutralLandClumps,        2)
  1286. #define        (kOuterNeutralFlatChaos,        0.8)
  1287. #define        (kOuterNeutralFlatClumps,        1)
  1288.  
  1289.  
  1290. //////////////////////////////////////////////////////////////////////
  1291. // resource definitions
  1292. #define        (kMaxResourceElevation,            3)
  1293. #define        (kResourceToEdgeDistance,        3)
  1294. #define        (kResourceToWaterDistance,        3)
  1295.  
  1296. #define        (kAnimalPerPlayer,            0)
  1297. #define        (kAnimalPerNeutral,            0)
  1298.  
  1299. #define        (kBerryPerPlayer,                1)
  1300. #define        (kBerryPerNeutral,            0)
  1301.  
  1302. #define        (kFishPerPlayer,                0)
  1303. #define        (kFishPerNeutral,                60)
  1304.  
  1305. #define        (kGoldPerPlayer,                2)
  1306. #define        (kGoldPerNeutral,                2)
  1307.  
  1308. #define        (kOilPerPlayer,                0)
  1309. #define        (kOilPerNeutral,                0)
  1310.  
  1311. #define        (kSteelPerPlayer,                2)
  1312. #define        (kSteelPerNeutral,            2)
  1313.  
  1314. #define        (kStonePerPlayer,                1)
  1315. #define        (kStonePerNeutral,            6)
  1316.  
  1317. #define        (kTreePerPlayer,                0)
  1318. #define        (kTreePerNeutral,                0)
  1319.  
  1320.  
  1321. //////////////////////////////////////////////////////////////////////
  1322. // forest definitions
  1323. #define        (kForestFreeRadius,            9.0)
  1324. #define        (kForestsPerPlayer,            2)
  1325. #define        (kForestChaosLevel,            0.9)
  1326. #define        (kMaxClumpsPerForest,              2)
  1327.  
  1328.  
  1329. #elif Is14Players
  1330. //////////////////////////////////////////////////////////////////////
  1331. // 14 PLAYERS...
  1332. //////////////////////////////////////////////////////////////////////
  1333.  
  1334. //////////////////////////////////////////////////////////////////////
  1335. // terrain definitions
  1336. #define        (kMinIntElevation,            -10)
  1337. #define        (kMaxIntElevation,            10)
  1338. #define        (kElevationScale,                0.99)
  1339. #define        (kPercentLand,                Between(.88, .88))
  1340. #define        (kWaterBorder,                0)
  1341. #define        (kHeightMapChaos,                Between(10, 20))
  1342.  
  1343. #define        (kMinimumStartPositionToMapEdge    4)
  1344. #define        (kOuterPushFromMapCenter        24)
  1345. #define        (kInnerPushFromMapCenter         0)                                            
  1346. //////////////////////////////////////////////////////////////////////
  1347. // player definitions
  1348. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  1349. #define        (kPlayerInnerRadius,            0.7)
  1350. #define        (kPlayerOuterRadius,            0.99)
  1351. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1352. #define        (kPlayerPercentFlat,            Between(0.6, 0.6))
  1353. #define        (kPlayerLandChaos,            0.8)
  1354. #define        (kPlayerLandClumps,            1)
  1355. #define        (kPlayerFlatChaos,            0.8)
  1356. #define        (kPlayerFlatClumps,            2)
  1357. #define        (kPlayerTreePercentage,            0.03)
  1358.  
  1359.  
  1360. //////////////////////////////////////////////////////////////////////
  1361. // inner neutral definitions
  1362. #define        (kNeutralInnerRadius,            0.45)
  1363. #define        (kNeutralOuterRadius,            0.45)
  1364. #define        (kNeutralOptimalFactor,            0.7)
  1365. #define        (kNumInnerNeutrals,            Between(3, 3))
  1366. #define        (kInnerNeutralPercentLand,        0.1)
  1367. #define        (kInnerNeutralPercentFlat,        Between(.8, .8))
  1368. #define        (kInnerNeutralTreePercentage,          0.12)
  1369. #define        (kInnerNeutralLandChaos,        0.9)
  1370. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1371. #define        (kInnerNeutralFlatChaos,        0.8)
  1372. #define        (kInnerNeutralFlatClumps,        1)
  1373.  
  1374.  
  1375. //////////////////////////////////////////////////////////////////////
  1376. // outer neutral definitions
  1377. #define        (kNumOuterNeutrals,            22)
  1378. #define        (kOuterNeutralPercentLand,        0.6)
  1379. #define        (kOuterNeutralPercentFlat,        Between(.6, .8))
  1380. #define        (kOuterNeutralTreePercentage,          0.07)
  1381. #define        (kOuterNeutralLandChaos,        0.8)
  1382. #define        (kOuterNeutralLandClumps,        2)
  1383. #define        (kOuterNeutralFlatChaos,        0.8)
  1384. #define        (kOuterNeutralFlatClumps,        1)
  1385.  
  1386.  
  1387. //////////////////////////////////////////////////////////////////////
  1388. // resource definitions
  1389. #define        (kMaxResourceElevation,            3)
  1390. #define        (kResourceToEdgeDistance,        3)
  1391. #define        (kResourceToWaterDistance,        3)
  1392.  
  1393. #define        (kAnimalPerPlayer,            0)
  1394. #define        (kAnimalPerNeutral,            0)
  1395.  
  1396. #define        (kBerryPerPlayer,                1)
  1397. #define        (kBerryPerNeutral,            0)
  1398.  
  1399. #define        (kFishPerPlayer,                0)
  1400. #define        (kFishPerNeutral,                60)
  1401.  
  1402. #define        (kGoldPerPlayer,                2)
  1403. #define        (kGoldPerNeutral,                2)
  1404.  
  1405. #define        (kOilPerPlayer,                0)
  1406. #define        (kOilPerNeutral,                0)
  1407.  
  1408. #define        (kSteelPerPlayer,                2)
  1409. #define        (kSteelPerNeutral,            2)
  1410.  
  1411. #define        (kStonePerPlayer,                1)
  1412. #define        (kStonePerNeutral,            6)
  1413.  
  1414. #define        (kTreePerPlayer,                0)
  1415. #define        (kTreePerNeutral,                0)
  1416.  
  1417.  
  1418. //////////////////////////////////////////////////////////////////////
  1419. // forest definitions
  1420. #define        (kForestFreeRadius,            9.0)
  1421. #define        (kForestsPerPlayer,            2)
  1422. #define        (kForestChaosLevel,            0.9)
  1423. #define        (kMaxClumpsPerForest,              2)
  1424.  
  1425.  
  1426. #elif Is15Players
  1427. //////////////////////////////////////////////////////////////////////
  1428. // 15 PLAYERS...
  1429. //////////////////////////////////////////////////////////////////////
  1430.  
  1431. //////////////////////////////////////////////////////////////////////
  1432. // terrain definitions
  1433. #define        (kMinIntElevation,            -10)
  1434. #define        (kMaxIntElevation,            10)
  1435. #define        (kElevationScale,                0.99)
  1436. #define        (kPercentLand,                Between(.88, .88))
  1437. #define        (kWaterBorder,                0)
  1438. #define        (kHeightMapChaos,                Between(10, 20))
  1439.  
  1440. #define        (kMinimumStartPositionToMapEdge    4)
  1441. #define        (kOuterPushFromMapCenter        24)
  1442. #define        (kInnerPushFromMapCenter         0)                                            
  1443. //////////////////////////////////////////////////////////////////////
  1444. // player definitions
  1445. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  1446. #define        (kPlayerInnerRadius,            0.7)
  1447. #define        (kPlayerOuterRadius,            0.99)
  1448. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1449. #define        (kPlayerPercentFlat,            Between(0.6, 0.6))
  1450. #define        (kPlayerLandChaos,            0.8)
  1451. #define        (kPlayerLandClumps,            1)
  1452. #define        (kPlayerFlatChaos,            0.8)
  1453. #define        (kPlayerFlatClumps,            2)
  1454. #define        (kPlayerTreePercentage,            0.03)
  1455.  
  1456.  
  1457. //////////////////////////////////////////////////////////////////////
  1458. // inner neutral definitions
  1459. #define        (kNeutralInnerRadius,            0.45)
  1460. #define        (kNeutralOuterRadius,            0.45)
  1461. #define        (kNeutralOptimalFactor,            0.7)
  1462. #define        (kNumInnerNeutrals,            Between(3, 3))
  1463. #define        (kInnerNeutralPercentLand,        0.1)
  1464. #define        (kInnerNeutralPercentFlat,        Between(.8, .8))
  1465. #define        (kInnerNeutralTreePercentage,          0.12)
  1466. #define        (kInnerNeutralLandChaos,        0.9)
  1467. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1468. #define        (kInnerNeutralFlatChaos,        0.8)
  1469. #define        (kInnerNeutralFlatClumps,        1)
  1470.  
  1471.  
  1472. //////////////////////////////////////////////////////////////////////
  1473. // outer neutral definitions
  1474. #define        (kNumOuterNeutrals,            22)
  1475. #define        (kOuterNeutralPercentLand,        0.6)
  1476. #define        (kOuterNeutralPercentFlat,        Between(.6, .8))
  1477. #define        (kOuterNeutralTreePercentage,          0.07)
  1478. #define        (kOuterNeutralLandChaos,        0.8)
  1479. #define        (kOuterNeutralLandClumps,        2)
  1480. #define        (kOuterNeutralFlatChaos,        0.8)
  1481. #define        (kOuterNeutralFlatClumps,        1)
  1482.  
  1483.  
  1484. //////////////////////////////////////////////////////////////////////
  1485. // resource definitions
  1486. #define        (kMaxResourceElevation,            3)
  1487. #define        (kResourceToEdgeDistance,        3)
  1488. #define        (kResourceToWaterDistance,        3)
  1489.  
  1490. #define        (kAnimalPerPlayer,            0)
  1491. #define        (kAnimalPerNeutral,            0)
  1492.  
  1493. #define        (kBerryPerPlayer,                1)
  1494. #define        (kBerryPerNeutral,            0)
  1495.  
  1496. #define        (kFishPerPlayer,                0)
  1497. #define        (kFishPerNeutral,                60)
  1498.  
  1499. #define        (kGoldPerPlayer,                2)
  1500. #define        (kGoldPerNeutral,                2)
  1501.  
  1502. #define        (kOilPerPlayer,                0)
  1503. #define        (kOilPerNeutral,                0)
  1504.  
  1505. #define        (kSteelPerPlayer,                2)
  1506. #define        (kSteelPerNeutral,            2)
  1507.  
  1508. #define        (kStonePerPlayer,                1)
  1509. #define        (kStonePerNeutral,            6)
  1510.  
  1511. #define        (kTreePerPlayer,                0)
  1512. #define        (kTreePerNeutral,                0)
  1513.  
  1514.  
  1515. //////////////////////////////////////////////////////////////////////
  1516. // forest definitions
  1517. #define        (kForestFreeRadius,            9.0)
  1518. #define        (kForestsPerPlayer,            2)
  1519. #define        (kForestChaosLevel,            0.9)
  1520. #define        (kMaxClumpsPerForest,              2)
  1521.  
  1522.  
  1523. #elif Is16Players
  1524. //////////////////////////////////////////////////////////////////////
  1525. // 16 PLAYERS...
  1526. //////////////////////////////////////////////////////////////////////
  1527.  
  1528. //////////////////////////////////////////////////////////////////////
  1529. // terrain definitions
  1530. #define        (kMinIntElevation,            -10)
  1531. #define        (kMaxIntElevation,            10)
  1532. #define        (kElevationScale,                0.99)
  1533. #define        (kPercentLand,                Between(.88, .88))
  1534. #define        (kWaterBorder,                0)
  1535. #define        (kHeightMapChaos,                Between(10, 20))
  1536.  
  1537. #define        (kMinimumStartPositionToMapEdge    4)
  1538. #define        (kOuterPushFromMapCenter        24)
  1539. #define        (kInnerPushFromMapCenter         0)                                            
  1540. //////////////////////////////////////////////////////////////////////
  1541. // player definitions
  1542. #define        (kMaxAngleBetweenTeamMembers,        20.0)
  1543. #define        (kPlayerInnerRadius,            0.7)
  1544. #define        (kPlayerOuterRadius,            0.99)
  1545. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1546. #define        (kPlayerPercentFlat,            Between(0.6, 0.6))
  1547. #define        (kPlayerLandChaos,            0.8)
  1548. #define        (kPlayerLandClumps,            1)
  1549. #define        (kPlayerFlatChaos,            0.8)
  1550. #define        (kPlayerFlatClumps,            2)
  1551. #define        (kPlayerTreePercentage,            0.03)
  1552.  
  1553.  
  1554. //////////////////////////////////////////////////////////////////////
  1555. // inner neutral definitions
  1556. #define        (kNeutralInnerRadius,            0.45)
  1557. #define        (kNeutralOuterRadius,            0.45)
  1558. #define        (kNeutralOptimalFactor,            0.7)
  1559. #define        (kNumInnerNeutrals,            Between(3, 3))
  1560. #define        (kInnerNeutralPercentLand,        0.1)
  1561. #define        (kInnerNeutralPercentFlat,        Between(.8, .8))
  1562. #define        (kInnerNeutralTreePercentage,          0.12)
  1563. #define        (kInnerNeutralLandChaos,        0.9)
  1564. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1565. #define        (kInnerNeutralFlatChaos,        0.8)
  1566. #define        (kInnerNeutralFlatClumps,        1)
  1567.  
  1568.  
  1569. //////////////////////////////////////////////////////////////////////
  1570. // outer neutral definitions
  1571. #define        (kNumOuterNeutrals,            22)
  1572. #define        (kOuterNeutralPercentLand,        0.6)
  1573. #define        (kOuterNeutralPercentFlat,        Between(.6, .8))
  1574. #define        (kOuterNeutralTreePercentage,          0.07)
  1575. #define        (kOuterNeutralLandChaos,        0.8)
  1576. #define        (kOuterNeutralLandClumps,        2)
  1577. #define        (kOuterNeutralFlatChaos,        0.8)
  1578. #define        (kOuterNeutralFlatClumps,        1)
  1579.  
  1580.  
  1581. //////////////////////////////////////////////////////////////////////
  1582. // resource definitions
  1583. #define        (kMaxResourceElevation,            3)
  1584. #define        (kResourceToEdgeDistance,        3)
  1585. #define        (kResourceToWaterDistance,        3)
  1586.  
  1587. #define        (kAnimalPerPlayer,            0)
  1588. #define        (kAnimalPerNeutral,            0)
  1589.  
  1590. #define        (kBerryPerPlayer,                1)
  1591. #define        (kBerryPerNeutral,            0)
  1592.  
  1593. #define        (kFishPerPlayer,                0)
  1594. #define        (kFishPerNeutral,                60)
  1595.  
  1596. #define        (kGoldPerPlayer,                2)
  1597. #define        (kGoldPerNeutral,                2)
  1598.  
  1599. #define        (kOilPerPlayer,                0)
  1600. #define        (kOilPerNeutral,                0)
  1601.  
  1602. #define        (kSteelPerPlayer,                2)
  1603. #define        (kSteelPerNeutral,            2)
  1604.  
  1605. #define        (kStonePerPlayer,                1)
  1606. #define        (kStonePerNeutral,            6)
  1607.  
  1608. #define        (kTreePerPlayer,                0)
  1609. #define        (kTreePerNeutral,                0)
  1610.  
  1611.  
  1612. //////////////////////////////////////////////////////////////////////
  1613. // forest definitions
  1614. #define        (kForestFreeRadius,            9.0)
  1615. #define        (kForestsPerPlayer,            2)
  1616. #define        (kForestChaosLevel,            0.9)
  1617. #define        (kMaxClumpsPerForest,              2)
  1618.  
  1619.  
  1620. //////////////////////////////////////////////////////////////////////
  1621. // End of if...elif... command
  1622. #endif
  1623.  
  1624.  
  1625. #endif        // NOTDEFINED(MEDITERRANEAN_LARGE_RMV)
  1626.